﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Bastanteo.Domain;
using Bastanteo.Persistencia;

namespace Bastanteo.Negocio
{
    public class AdministracionServiceImpl : IAdministracionService
    {
        #region Dependencias
        IRolDAO rolDAO = null;
        IUsuarioDAO usuarioDAO = null;
        IrepresentanteDAO representanteDAO = null;
        ICargoDAO cargoDAO = null;
        IGrupoDAO grupoDAO = null;
        #endregion

        #region Métodos de soporte para entidad Local
        public Rol CrearRol(Rol rolACrear)
        {
            ICollection<Rol> existentes = rolDAO.ListarXNombre(rolACrear.RolDescripcion);
            if (existentes.Count > 0)
                throw new EntidadRepetidaException("Rol ya existente");
            return rolDAO.Crear(rolACrear);
        }
        public Rol ObtenerRol(int codigo)
        {
            return rolDAO.Obtener(codigo);
        }
        public Rol ModificarRol(Rol objAModificar)
        {
            return rolDAO.Modificar(objAModificar);
        }
        public void EliminarRol(Rol objAEliminar)
        {
            rolDAO.Eliminar(objAEliminar);
        }
        public ICollection<Rol> ListarRoles()
        {
            return rolDAO.Listar();
        }
        public ICollection<Rol> ListarRolesXNombre(string nombre)
        {
            if (nombre == null)
            {
                throw new DatosInsuficientesException("Tiene que ingresar la descripcion del Rol para poder buscar");
            }
            return rolDAO.ListarXNombre(nombre);
        }
        #endregion

        #region Métodos de soporte para entidad Usuario
        public Usuario CrearUsuario(Usuario ObjACrear)
        {
            ICollection<Usuario> existentes = usuarioDAO.ListarXBusqueda(null, ObjACrear.usuario, null);
            ICollection<Usuario> existentes1 = usuarioDAO.ListarXBusqueda(ObjACrear.Codigo, null, null);
            if (existentes.Count > 0 || existentes1.Count > 0)
                throw new EntidadRepetidaException("Usuario ya existente");
            if (ObjACrear.Rol == null)
                throw new DatosInsuficientesException("Debe Seleccionar un Rol");
            return usuarioDAO.Crear(ObjACrear);
        }
        public Usuario ObtenerUsuario(int codigo)
        {
            return usuarioDAO.Obtener(codigo);
        }
        public Usuario ModificarUsuario(Usuario objAModificar)
        {
            return usuarioDAO.Modificar(objAModificar);
        }
        public void EliminarUsuario(Usuario objAEliminar)
        {
            usuarioDAO.Eliminar(objAEliminar);
        }
        public ICollection<Usuario> ListarUsuarios()
        {
            return usuarioDAO.Listar();
        }
        public ICollection<Usuario> ListarUsuariosXBusqueda(string codigo, string usuario, int rolCodigo)
        {
            if (codigo == null && usuario == null && rolCodigo == 0)
            {
                //throw new DatosInsuficientesException("Tiene que ingresar un Criterio de Busqueda");
            }

            Rol ObjExistente = null;
            if (rolCodigo != null && rolCodigo != 0)
                ObjExistente = rolDAO.Obtener(rolCodigo);
            return usuarioDAO.ListarXBusqueda(codigo, usuario, ObjExistente);
        }
        #endregion

        #region Métodos de soporte para entidad Representante
        public Representante CrearRepresentante(Representante ObjACrear)
        {
            //ICollection<Usuario> existentes = usuarioDAO.ListarXBusqueda(null, ObjACrear.usuario, null);
            //ICollection<Usuario> existentes1 = usuarioDAO.ListarXBusqueda(ObjACrear.Codigo, null, null);
            //if (existentes.Count > 0 || existentes1.Count > 0)
            //    throw new EntidadRepetidaException("Usuario ya existente");
            //if (ObjACrear.Rol == null)
            //    throw new DatosInsuficientesException("Debe Seleccionar un Rol");
            return representanteDAO.Crear(ObjACrear);
        }
        public Representante ObtenerRepresentante(string codigo)
        {
            return representanteDAO.Obtener(codigo); 
        }
        public Representante ModificarRepresentante(Representante objAModificar)
        {
            return representanteDAO.Modificar(objAModificar);
        }
        public void EliminarRepresentante(Representante objAEliminar)
        {
            representanteDAO.Eliminar(objAEliminar);
        }
        public ICollection<Representante> ListarRepresenta()
        {
            return representanteDAO.Listar();
        }
        public ICollection<Representante> ListarRepresentanteXBusqueda(string numdoc, string tipodoc, string representante, int cargoCodigo)
        {
            if (numdoc == null && tipodoc == null && representante == null && cargoCodigo == 0)
            {
                //throw new DatosInsuficientesException("Tiene que ingresar un Criterio de Busqueda");
            }

            Cargo ObjExistente = null;
            if (cargoCodigo != null && cargoCodigo != 0)
                ObjExistente = cargoDAO.Obtener(cargoCodigo);
            return representanteDAO.ListarXBusqueda(numdoc, tipodoc, representante, ObjExistente);
            //return representanteDAO.ListarXBusqueda("", "", "", ObjExistente);

        }
        #endregion

        #region Métodos de soporte para entidad  Cargo
        public Cargo CrearCargo(Cargo cargoACrear)
        {
            ICollection<Cargo> existentes = cargoDAO.ListarXNombre(cargoACrear.CargoDescripcion);
            if (existentes.Count > 0)
                throw new EntidadRepetidaException("Cargo ya existente");
            return cargoDAO.Crear(cargoACrear);
        }
        public Cargo ObtenerCargo(int codigo)
        {
            return cargoDAO.Obtener(codigo);
        }
        public Cargo ModificarCargo(Cargo objAModificar)
        {
            return cargoDAO.Modificar(objAModificar);
        }
        public void EliminarCargo(Cargo objAEliminar)
        {
            cargoDAO.Eliminar(objAEliminar);
        }
        public ICollection<Cargo> ListarCargo()
        {
            return cargoDAO.Listar();
        }
        public ICollection<Cargo> ListarCargoXNombre(string nombre)
        {
            if (nombre == null)
            {
                throw new DatosInsuficientesException("Tiene que ingresar la descripcion del Cargos para poder buscar");
            }
            return cargoDAO.ListarXNombre(nombre);
        }
        #endregion

        #region Métodos de soporte para entidad Grupo
        public Grupo CrearGrupo(Grupo grupoACrear)
        {
            ICollection<Grupo> existentes = grupoDAO.ListarXNombre(grupoACrear.GrupoDescripcion);
            if (existentes.Count > 0)
                throw new EntidadRepetidaException("Grupo ya existente");
            return grupoDAO.Crear(grupoACrear);
        }
        public Grupo ObtenerGrupo(int codigo)
        {
            return grupoDAO.Obtener(codigo);
        }
        public Grupo ModificarGrupo(Grupo objAModificar)
        {
            return grupoDAO.Modificar(objAModificar);
        }
        public void EliminarGrupo(Grupo objAEliminar)
        {
            grupoDAO.Eliminar(objAEliminar);
        }
        public ICollection<Grupo> ListarGrupos()
        {
            return grupoDAO.Listar();
        }
        public ICollection<Grupo> ListarGruposXNombre(string nombre)
        {
            if (nombre == null)
            {
                throw new DatosInsuficientesException("Tiene que ingresar la descripcion del Grupo para poder buscar");
            }
            return grupoDAO.ListarXNombre(nombre);
        }
        #endregion

    }
}